Sky at Night 2007 June/SAN CD 6-2007 CD-ROM 25.iso/pc/Software/AstroGrav_Win/Java/jre1.6.0/lib/rt.jar/sun/awt/SunToolkit.class

Java Class File | 2006-11-29 | 27.3 KB | 1,263 lines

package sun.awt;

import java.awt.AWTEvent;
import java.awt.AWTException;
import java.awt.Button;
import java.awt.Canvas;
import java.awt.Checkbox;
import java.awt.CheckboxMenuItem;
import java.awt.Choice;
import java.awt.Component;
import java.awt.Container;
import java.awt.DefaultFocusTraversalPolicy;
import java.awt.DefaultKeyboardFocusManager;
import java.awt.Dialog;
import java.awt.Dimension;
import java.awt.EventQueue;
import java.awt.FileDialog;
import java.awt.FocusTraversalPolicy;
import java.awt.Font;
import java.awt.FontMetrics;
import java.awt.Frame;
import java.awt.Graphics2D;
import java.awt.GraphicsDevice;
import java.awt.GraphicsEnvironment;
import java.awt.HeadlessException;
import java.awt.Image;
import java.awt.KeyboardFocusManager;
import java.awt.Label;
import java.awt.List;
import java.awt.Menu;
import java.awt.MenuBar;
import java.awt.MenuComponent;
import java.awt.MenuItem;
import java.awt.Panel;
import java.awt.PopupMenu;
import java.awt.RenderingHints;
import java.awt.Robot;
import java.awt.ScrollPane;
import java.awt.Scrollbar;
import java.awt.SystemTray;
import java.awt.TextArea;
import java.awt.TextField;
import java.awt.Toolkit;
import java.awt.TrayIcon;
import java.awt.Window;
import java.awt.Dialog.ModalExclusionType;
import java.awt.Dialog.ModalityType;
import java.awt.dnd.DragGestureEvent;
import java.awt.dnd.InvalidDnDOperationException;
import java.awt.dnd.peer.DragSourceContextPeer;
import java.awt.event.KeyEvent;
import java.awt.event.WindowEvent;
import java.awt.image.BufferedImage;
import java.awt.image.DataBuffer;
import java.awt.image.DataBufferInt;
import java.awt.image.ImageObserver;
import java.awt.image.ImageProducer;
import java.awt.image.Raster;
import java.awt.image.WritableRaster;
import java.awt.peer.ButtonPeer;
import java.awt.peer.CanvasPeer;
import java.awt.peer.CheckboxMenuItemPeer;
import java.awt.peer.CheckboxPeer;
import java.awt.peer.ChoicePeer;
import java.awt.peer.DialogPeer;
import java.awt.peer.FileDialogPeer;
import java.awt.peer.FontPeer;
import java.awt.peer.FramePeer;
import java.awt.peer.KeyboardFocusManagerPeer;
import java.awt.peer.LabelPeer;
import java.awt.peer.ListPeer;
import java.awt.peer.MenuBarPeer;
import java.awt.peer.MenuItemPeer;
import java.awt.peer.MenuPeer;
import java.awt.peer.MouseInfoPeer;
import java.awt.peer.PanelPeer;
import java.awt.peer.PopupMenuPeer;
import java.awt.peer.RobotPeer;
import java.awt.peer.ScrollPanePeer;
import java.awt.peer.ScrollbarPeer;
import java.awt.peer.SystemTrayPeer;
import java.awt.peer.TextAreaPeer;
import java.awt.peer.TextFieldPeer;
import java.awt.peer.TrayIconPeer;
import java.awt.peer.WindowPeer;
import java.io.FilePermission;
import java.io.IOException;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.net.SocketPermission;
import java.net.URL;
import java.security.AccessController;
import java.security.Permission;
import java.security.PrivilegedActionException;
import java.util.Collections;
import java.util.Hashtable;
import java.util.Locale;
import java.util.Map;
import java.util.WeakHashMap;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;
import java.util.logging.Level;
import java.util.logging.Logger;
import sun.awt.im.InputContext;
import sun.awt.im.SimpleInputMethodWindow;
import sun.awt.image.ByteArrayImageSource;
import sun.awt.image.FileImageSource;
import sun.awt.image.ImageRepresentation;
import sun.awt.image.ToolkitImage;
import sun.awt.image.URLImageSource;
import sun.font.FontDesignMetrics;
import sun.misc.SoftCache;
import sun.security.action.GetBooleanAction;
import sun.security.action.GetPropertyAction;

public abstract class SunToolkit extends Toolkit implements WindowClosingSupport, WindowClosingListener, ComponentFactory, InputMethodSupport {
   private static final Logger log = Logger.getLogger("sun.awt.SunToolkit");
   public static final int GRAB_EVENT_MASK = Integer.MIN_VALUE;
   private static Field syncLWRequestsField;
   private static Method wakeupMethod;
   private static Field componentKeyField;
   private static Field menuComponentKeyField;
   private static Field trayIconKeyField;
   private static Field isPostedField;
   private static final String POST_EVENT_QUEUE_KEY = "PostEventQueue";
   private static final ReentrantLock AWT_LOCK = new ReentrantLock();
   private static final Condition AWT_LOCK_COND;
   protected static final Hashtable peerMap;
   private static final Map appContextMap;
   static SoftCache imgCache;
   private static Locale startupLocale;
   private static String dataTransfererClassName;
   private transient WindowClosingListener windowClosingListener;
   private static DefaultMouseInfoPeer mPeer;
   private static Dialog.ModalExclusionType DEFAULT_MODAL_EXCLUSION_TYPE;
   private ModalityListenerList modalityListeners;
   public static final int WAIT_TIME = 10000;
   private static final int MAX_ITERS = 20;
   private static final int MIN_ITERS = 0;
   private static final int MINIMAL_EDELAY = 0;
   private boolean eventDispatched;
   private boolean queueEmpty;
   private final Object waitLock;
   static Method eqNoEvents;
   private static boolean checkedSystemAAFontSettings;
   private static boolean useSystemAAFontSettings;
   private static boolean lastExtraCondition;
   private static RenderingHints desktopFontHints;
   public static final String DESKTOPFONTHINTS = "awt.font.desktophints";
   private static Method consumeNextKeyTypedMethod;

   public SunToolkit() {
      DebugHelper.init();
      this.windowClosingListener = null;
      this.modalityListeners = new ModalityListenerList();
      this.eventDispatched = false;
      this.queueEmpty = false;
      this.waitLock = "Wait Lock";
      ThreadGroup var1 = null;
      String var2 = System.getProperty("awt.threadgroup", "");
      if (var2.length() != 0) {
         try {
            Constructor var3 = Class.forName(var2).getConstructor(String.class);
            var1 = (ThreadGroup)var3.newInstance("AWT-ThreadGroup");
         } catch (Exception var7) {
            System.err.println("Failed loading " + var2 + ": " + var7);
         }
      }

      1 var8 = new 1(this);
      if (var1 != null) {
         Thread var4 = new Thread(var1, var8, "EventQueue-Init");
         var4.start();

         try {
            var4.join();
         } catch (InterruptedException var6) {
            var6.printStackTrace();
         }
      } else {
         var8.run();
      }

   }

   public boolean useBufferPerWindow() {
      return false;
   }

   public abstract WindowPeer createWindow(Window var1) throws HeadlessException;

   public abstract FramePeer createFrame(Frame var1) throws HeadlessException;

   public abstract DialogPeer createDialog(Dialog var1) throws HeadlessException;

   public abstract ButtonPeer createButton(Button var1) throws HeadlessException;

   public abstract TextFieldPeer createTextField(TextField var1) throws HeadlessException;

   public abstract ChoicePeer createChoice(Choice var1) throws HeadlessException;

   public abstract LabelPeer createLabel(Label var1) throws HeadlessException;

   public abstract ListPeer createList(List var1) throws HeadlessException;

   public abstract CheckboxPeer createCheckbox(Checkbox var1) throws HeadlessException;

   public abstract ScrollbarPeer createScrollbar(Scrollbar var1) throws HeadlessException;

   public abstract ScrollPanePeer createScrollPane(ScrollPane var1) throws HeadlessException;

   public abstract TextAreaPeer createTextArea(TextArea var1) throws HeadlessException;

   public abstract FileDialogPeer createFileDialog(FileDialog var1) throws HeadlessException;

   public abstract MenuBarPeer createMenuBar(MenuBar var1) throws HeadlessException;

   public abstract MenuPeer createMenu(Menu var1) throws HeadlessException;

   public abstract PopupMenuPeer createPopupMenu(PopupMenu var1) throws HeadlessException;

   public abstract MenuItemPeer createMenuItem(MenuItem var1) throws HeadlessException;

   public abstract CheckboxMenuItemPeer createCheckboxMenuItem(CheckboxMenuItem var1) throws HeadlessException;

   public abstract DragSourceContextPeer createDragSourceContextPeer(DragGestureEvent var1) throws InvalidDnDOperationException;

   public abstract TrayIconPeer createTrayIcon(TrayIcon var1) throws HeadlessException, AWTException;

   public abstract SystemTrayPeer createSystemTray(SystemTray var1);

   public abstract boolean isTraySupported();

   public abstract FontPeer getFontPeer(String var1, int var2);

   public abstract RobotPeer createRobot(Robot var1, GraphicsDevice var2) throws AWTException;

   public KeyboardFocusManagerPeer createKeyboardFocusManagerPeer(KeyboardFocusManager var1) throws HeadlessException {
      KeyboardFocusManagerPeerImpl var2 = new KeyboardFocusManagerPeerImpl(var1);
      return var2;
   }

   public static final void awtLock() {
      AWT_LOCK.lock();
   }

   public static final boolean awtTryLock() {
      return AWT_LOCK.tryLock();
   }

   public static final void awtUnlock() {
      AWT_LOCK.unlock();
   }

   public static final void awtLockWait() throws InterruptedException {
      AWT_LOCK_COND.await();
   }

   public static final void awtLockWait(long var0) throws InterruptedException {
      AWT_LOCK_COND.await(var0, TimeUnit.MILLISECONDS);
   }

   public static final void awtLockNotify() {
      AWT_LOCK_COND.signal();
   }

   public static final void awtLockNotifyAll() {
      AWT_LOCK_COND.signalAll();
   }

   public static final boolean isAWTLockHeldByCurrentThread() {
      return AWT_LOCK.isHeldByCurrentThread();
   }

   public static AppContext createNewAppContext() {
      ThreadGroup var0 = Thread.currentThread().getThreadGroup();
      String var2 = Toolkit.getProperty("AWT.EventQueueClass", "java.awt.EventQueue");

      EventQueue var1;
      try {
         var1 = (EventQueue)Class.forName(var2).newInstance();
      } catch (Exception var5) {
         System.err.println("Failed loading " + var2 + ": " + var5);
         var1 = new EventQueue();
      }

      AppContext var3 = new AppContext(var0);
      var3.put(AppContext.EVENT_QUEUE_KEY, var1);
      PostEventQueue var4 = new PostEventQueue(var1);
      var3.put("PostEventQueue", var4);
      return var3;
   }

   private static Object getPrivateKey(Object var0) {
      Object var1 = null;

      try {
         if (var0 instanceof Component) {
            if (componentKeyField == null) {
               componentKeyField = getField(Component.class, "privateKey");
            }

            var1 = componentKeyField.get(var0);
         } else if (var0 instanceof MenuComponent) {
            if (menuComponentKeyField == null) {
               menuComponentKeyField = getField(MenuComponent.class, "privateKey");
            }

            var1 = menuComponentKeyField.get(var0);
         } else if (var0 instanceof TrayIcon) {
            if (trayIconKeyField == null) {
               trayIconKeyField = getField(TrayIcon.class, "privateKey");
            }

            var1 = trayIconKeyField.get(var0);
         }
      } catch (IllegalAccessException var3) {
         assert false;
      }

      return var1;
   }

   private static Field getField(Class var0, String var1) {
      return (Field)AccessController.doPrivileged(new 2(var0, var1));
   }

   static void wakeupEventQueue(EventQueue var0, boolean var1) {
      if (wakeupMethod == null) {
         wakeupMethod = (Method)AccessController.doPrivileged(new 3());
      }

      try {
         if (wakeupMethod != null) {
            wakeupMethod.invoke(var0, var1);
         }
      } catch (InvocationTargetException var3) {
         assert false;
      } catch (IllegalAccessException var4) {
         assert false;
      }

   }

   protected static Object targetToPeer(Object var0) {
      return var0 != null && !GraphicsEnvironment.isHeadless() ? peerMap.get(getPrivateKey(var0)) : null;
   }

   protected static void targetCreatedPeer(Object var0, Object var1) {
      if (var0 != null && var1 != null && !GraphicsEnvironment.isHeadless()) {
         peerMap.put(getPrivateKey(var0), var1);
      }

   }

   protected static void targetDisposedPeer(Object var0, Object var1) {
      if (var0 != null && var1 != null && !GraphicsEnvironment.isHeadless()) {
         Object var2 = getPrivateKey(var0);
         if (peerMap.get(var2) == var1) {
            peerMap.remove(var2);
         }
      }

   }

   private static native boolean setAppContext(Object var0, AppContext var1);

   private static native AppContext getAppContext(Object var0);

   public static AppContext targetToAppContext(Object var0) {
      if (var0 != null && !GraphicsEnvironment.isHeadless()) {
         AppContext var1 = getAppContext(var0);
         if (var1 == null) {
            var1 = (AppContext)appContextMap.get(var0);
         }

         return var1;
      } else {
         return null;
      }
   }

   public static void setLWRequestStatus(Window var0, boolean var1) {
      if (syncLWRequestsField == null) {
         syncLWRequestsField = getField(Window.class, "syncLWRequests");
      }

      try {
         if (syncLWRequestsField != null) {
            syncLWRequestsField.setBoolean(var0, var1);
         }
      } catch (IllegalAccessException var3) {
         assert false;
      }

   }

   public static void checkAndSetPolicy(Container var0, boolean var1) {
      Object var2 = KeyboardFocusManager.getCurrentKeyboardFocusManager().getDefaultFocusTraversalPolicy();
      String var3 = Toolkit.getDefaultToolkit().getClass().getName();
      if (!"sun.awt.X11.XToolkit".equals(var3)) {
         var0.setFocusTraversalPolicy((FocusTraversalPolicy)var2);
      } else {
         String var4 = var2.getClass().getName();
         if (DefaultFocusTraversalPolicy.class != var2.getClass()) {
            if (var4.startsWith("java.awt.")) {
               if (var1) {
                  var2 = createLayoutPolicy();
               }
            } else if (var4.startsWith("javax.swing.") && !var1) {
               var2 = new DefaultFocusTraversalPolicy();
            }
         } else if (var1) {
            var2 = createLayoutPolicy();
         }

         var0.setFocusTraversalPolicy((FocusTraversalPolicy)var2);
      }
   }

   private static FocusTraversalPolicy createLayoutPolicy() {
      FocusTraversalPolicy var0 = null;

      try {
         Class var1 = Class.forName("javax.swing.LayoutFocusTraversalPolicy");
         var0 = (FocusTraversalPolicy)var1.newInstance();
      } catch (ClassNotFoundException var2) {
         assert false;
      } catch (InstantiationException var3) {
         assert false;
      } catch (IllegalAccessException var4) {
         assert false;
      }

      return var0;
   }

   public static void insertTargetMapping(Object var0, AppContext var1) {
      if (!GraphicsEnvironment.isHeadless() && !setAppContext(var0, var1)) {
         appContextMap.put(var0, var1);
      }

   }

   public static void postEvent(AppContext var0, AWTEvent var1) {
      if (var1 == null) {
         throw new NullPointerException();
      } else {
         AppContext var2 = targetToAppContext(var1.getSource());
         if (var2 != null && !var2.equals(var0)) {
            log.fine("Event posted on wrong app context : " + var1);
         }

         PostEventQueue var3 = (PostEventQueue)var0.get("PostEventQueue");
         if (var3 != null) {
            var3.postEvent(var1);
         }

      }
   }

   public static void postPriorityEvent(AWTEvent var0) {
      if (isPostedField == null) {
         isPostedField = getField(AWTEvent.class, "isPosted");
      }

      PeerEvent var1 = new PeerEvent(Toolkit.getDefaultToolkit(), new 4(var0), 2L);
      postEvent(targetToAppContext(var0.getSource()), var1);
   }

   public static void flushPendingEvents() {
      AppContext var0 = AppContext.getAppContext();
      PostEventQueue var1 = (PostEventQueue)var0.get("PostEventQueue");
      if (var1 != null) {
         var1.flush();
      }

   }

   public static boolean isPostEventQueueEmpty() {
      AppContext var0 = AppContext.getAppContext();
      PostEventQueue var1 = (PostEventQueue)var0.get("PostEventQueue");
      return var1 != null ? var1.noEvents() : true;
   }

   public static void executeOnEventHandlerThread(Object var0, Runnable var1) {
      executeOnEventHandlerThread(new PeerEvent(var0, var1, 1L));
   }

   public static void executeOnEventHandlerThread(Object var0, Runnable var1, long var2) {
      executeOnEventHandlerThread(new 5(var0, var1, 1L, var2));
   }

   public static void executeOnEventHandlerThread(PeerEvent var0) {
      postEvent(targetToAppContext(var0.getSource()), var0);
   }

   public static void executeOnEDTAndWait(Object var0, Runnable var1) throws InterruptedException, InvocationTargetException {
      if (EventQueue.isDispatchThread()) {
         throw new Error("Cannot call executeOnEDTAndWait from any event dispatcher thread");
      } else {
         1AWTInvocationLock var2 = new 1AWTInvocationLock();
         PeerEvent var3 = new PeerEvent(var0, var1, var2, true, 1L);
         synchronized(var2) {
            executeOnEventHandlerThread(var3);
            var2.wait();
         }

         Throwable var4 = var3.getThrowable();
         if (var4 != null) {
            throw new InvocationTargetException(var4);
         }
      }
   }

   private static EventQueue getNextQueue(Object var0) {
      EventQueue var1 = null;

      try {
         Field var2 = getField(EventQueue.class, "nextQueue");
         var1 = (EventQueue)var2.get(var0);
      } catch (IllegalAccessException var3) {
         assert false;
      }

      return var1;
   }

   private static Thread getDispatchThread(Object var0) {
      Thread var1 = null;

      try {
         Field var2 = getField(EventQueue.class, "dispatchThread");
         var1 = (Thread)var2.get(var0);
      } catch (IllegalAccessException var3) {
         assert false;
      }

      return var1;
   }

   public static boolean isDispatchThreadForAppContext(Object var0) {
      AppContext var1 = targetToAppContext(var0);
      EventQueue var2 = (EventQueue)var1.get(AppContext.EVENT_QUEUE_KEY);

      for(EventQueue var3 = getNextQueue(var2); var3 != null; var3 = getNextQueue(var3)) {
         var2 = var3;
      }

      return Thread.currentThread() == getDispatchThread(var2);
   }

   public Dimension getScreenSize() {
      return new Dimension(this.getScreenWidth(), this.getScreenHeight());
   }

   protected abstract int getScreenWidth();

   protected abstract int getScreenHeight();

   public FontMetrics getFontMetrics(Font var1) {
      return FontDesignMetrics.getMetrics(var1);
   }

   public String[] getFontList() {
      String[] var1 = new String[]{"Dialog", "SansSerif", "Serif", "Monospaced", "DialogInput"};
      return var1;
   }

   public PanelPeer createPanel(Panel var1) {
      return (PanelPeer)this.createComponent(var1);
   }

   public CanvasPeer createCanvas(Canvas var1) {
      return (CanvasPeer)this.createComponent(var1);
   }

   public void disableBackgroundErase(Canvas var1) {
      if (!var1.isDisplayable()) {
         throw new IllegalStateException("Canvas must have a valid peer");
      }
   }

   static synchronized Image getImageFromHash(Toolkit var0, URL var1) {
      SecurityManager var2 = System.getSecurityManager();
      if (var2 != null) {
         try {
            Permission var3 = var1.openConnection().getPermission();
            if (var3 != null) {
               try {
                  var2.checkPermission(var3);
               } catch (SecurityException var6) {
                  if (var3 instanceof FilePermission && var3.getActions().indexOf("read") != -1) {
                     var2.checkRead(var3.getName());
                  } else {
                     if (!(var3 instanceof SocketPermission) || var3.getActions().indexOf("connect") == -1) {
                        throw var6;
                     }

                     var2.checkConnect(var1.getHost(), var1.getPort());
                  }
               }
            }
         } catch (IOException var7) {
            var2.checkConnect(var1.getHost(), var1.getPort());
         }
      }

      Image var8 = (Image)imgCache.get(var1);
      if (var8 == null) {
         try {
            var8 = var0.createImage(new URLImageSource(var1));
            imgCache.put(var1, var8);
         } catch (Exception var5) {
         }
      }

      return var8;
   }

   static synchronized Image getImageFromHash(Toolkit var0, String var1) {
      SecurityManager var2 = System.getSecurityManager();
      if (var2 != null) {
         var2.checkRead(var1);
      }

      Image var3 = (Image)imgCache.get(var1);
      if (var3 == null) {
         try {
            var3 = var0.createImage(new FileImageSource(var1));
            imgCache.put(var1, var3);
         } catch (Exception var5) {
         }
      }

      return var3;
   }

   public Image getImage(String var1) {
      return getImageFromHash(this, (String)var1);
   }

   public Image getImage(URL var1) {
      return getImageFromHash(this, (URL)var1);
   }

   public Image createImage(String var1) {
      SecurityManager var2 = System.getSecurityManager();
      if (var2 != null) {
         var2.checkRead(var1);
      }

      return this.createImage((ImageProducer)(new FileImageSource(var1)));
   }

   public Image createImage(URL var1) {
      SecurityManager var2 = System.getSecurityManager();
      if (var2 != null) {
         try {
            Permission var3 = var1.openConnection().getPermission();
            if (var3 != null) {
               try {
                  var2.checkPermission(var3);
               } catch (SecurityException var5) {
                  if (var3 instanceof FilePermission && var3.getActions().indexOf("read") != -1) {
                     var2.checkRead(var3.getName());
                  } else {
                     if (!(var3 instanceof SocketPermission) || var3.getActions().indexOf("connect") == -1) {
                        throw var5;
                     }

                     var2.checkConnect(var1.getHost(), var1.getPort());
                  }
               }
            }
         } catch (IOException var6) {
            var2.checkConnect(var1.getHost(), var1.getPort());
         }
      }

      return this.createImage((ImageProducer)(new URLImageSource(var1)));
   }

   public Image createImage(byte[] var1, int var2, int var3) {
      return this.createImage((ImageProducer)(new ByteArrayImageSource(var1, var2, var3)));
   }

   public Image createImage(ImageProducer var1) {
      return new ToolkitImage(var1);
   }

   public int checkImage(Image var1, int var2, int var3, ImageObserver var4) {
      if (!(var1 instanceof ToolkitImage)) {
         return 32;
      } else {
         ToolkitImage var5 = (ToolkitImage)var1;
         int var6;
         if (var2 != 0 && var3 != 0) {
            var6 = var5.getImageRep().check(var4);
         } else {
            var6 = 32;
         }

         return var5.check(var4) | var6;
      }
   }

   public boolean prepareImage(Image var1, int var2, int var3, ImageObserver var4) {
      if (var2 != 0 && var3 != 0) {
         if (!(var1 instanceof ToolkitImage)) {
            return true;
         } else {
            ToolkitImage var5 = (ToolkitImage)var1;
            if (var5.hasError()) {
               if (var4 != null) {
                  var4.imageUpdate(var1, 192, -1, -1, -1, -1);
               }

               return false;
            } else {
               ImageRepresentation var6 = var5.getImageRep();
               return var6.prepare(var4);
            }
         }
      } else {
         return true;
      }
   }

   public static BufferedImage getScaledIconImage(java.util.List<Image> var0, int var1, int var2) {
      if (var1 != 0 && var2 != 0) {
         Image var3 = null;
         int var4 = 0;
         int var5 = 0;
         double var6 = (double)3.0F;
         double var8 = (double)0.0F;

         for(Image var11 : var0) {
            if (var11 == null) {
               if (log.isLoggable(Level.FINEST)) {
                  log.finest("SunToolkit.getScaledIconImage: Skipping the image passed into Java because it's null.");
               }
            } else {
               if (var11 instanceof ToolkitImage) {
                  ImageRepresentation var12 = ((ToolkitImage)var11).getImageRep();
                  var12.reconstruct(32);
               }

               int var13;
               int var29;
               try {
                  var29 = var11.getWidth((ImageObserver)null);
                  var13 = var11.getHeight((ImageObserver)null);
               } catch (Exception var26) {
                  if (log.isLoggable(Level.FINEST)) {
                     log.finest("SunToolkit.getScaledIconImage: Perhaps the image passed into Java is broken. Skipping this icon.");
                  }
                  continue;
               }

               if (var29 > 0 && var13 > 0) {
                  double var14 = Math.min((double)var1 / (double)var29, (double)var2 / (double)var13);
                  int var16 = 0;
                  int var17 = 0;
                  double var18 = (double)1.0F;
                  if (var14 >= (double)2.0F) {
                     var14 = Math.floor(var14);
                     var16 = var29 * (int)var14;
                     var17 = var13 * (int)var14;
                     var18 = (double)1.0F - (double)0.5F / var14;
                  } else if (var14 >= (double)1.0F) {
                     var14 = (double)1.0F;
                     var16 = var29;
                     var17 = var13;
                     var18 = (double)0.0F;
                  } else if (var14 >= (double)0.75F) {
                     var14 = (double)0.75F;
                     var16 = var29 * 3 / 4;
                     var17 = var13 * 3 / 4;
                     var18 = 0.3;
                  } else if (var14 >= 0.6666) {
                     var14 = 0.6666;
                     var16 = var29 * 2 / 3;
                     var17 = var13 * 2 / 3;
                     var18 = 0.33;
                  } else {
                     double var20 = Math.ceil((double)1.0F / var14);
                     var14 = (double)1.0F / var20;
                     var16 = (int)Math.round((double)var29 / var20);
                     var17 = (int)Math.round((double)var13 / var20);
                     var18 = (double)1.0F - (double)1.0F / var20;
                  }

                  double var36 = ((double)var1 - (double)var16) / (double)var1 + ((double)var2 - (double)var17) / (double)var2 + var18;
                  if (var36 < var6) {
                     var6 = var36;
                     var8 = var14;
                     var3 = var11;
                     var4 = var16;
                     var5 = var17;
                  }

                  if (var36 == (double)0.0F) {
                     break;
                  }
               }
            }
         }

         if (var3 == null) {
            return null;
         } else {
            BufferedImage var27 = new BufferedImage(var1, var2, 2);
            Graphics2D var28 = var27.createGraphics();
            var28.setRenderingHint(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BILINEAR);

            try {
               int var30 = (var1 - var4) / 2;
               int var31 = (var2 - var5) / 2;
               if (log.isLoggable(Level.FINER)) {
                  log.finer("WWindowPeer.getScaledIconData() result : w : " + var1 + " h : " + var2 + " iW : " + var3.getWidth((ImageObserver)null) + " iH : " + var3.getHeight((ImageObserver)null) + " sim : " + var6 + " sf : " + var8 + " adjW : " + var4 + " adjH : " + var5 + " x : " + var30 + " y : " + var31);
               }

               var28.drawImage(var3, var30, var31, var4, var5, (ImageObserver)null);
            } finally {
               var28.dispose();
            }

            return var27;
         }
      } else {
         return null;
      }
   }

   public static DataBufferInt getScaledIconData(java.util.List<Image> var0, int var1, int var2) {
      BufferedImage var3 = getScaledIconImage(var0, var1, var2);
      if (var3 == null) {
         if (log.isLoggable(Level.FINEST)) {
            log.finest("SunToolkit.getScaledIconData: Perhaps the image passed into Java is broken. Skipping this icon.");
         }

         return null;
      } else {
         WritableRaster var4 = var3.getRaster();
         DataBuffer var5 = ((Raster)var4).getDataBuffer();
         return (DataBufferInt)var5;
      }
   }

   protected EventQueue getSystemEventQueueImpl() {
      return getSystemEventQueueImplPP();
   }

   static EventQueue getSystemEventQueueImplPP() {
      return getSystemEventQueueImplPP(AppContext.getAppContext());
   }

   public static EventQueue getSystemEventQueueImplPP(AppContext var0) {
      EventQueue var1 = (EventQueue)var0.get(AppContext.EVENT_QUEUE_KEY);
      return var1;
   }

   public static Container getNativeContainer(Component var0) {
      return Toolkit.getNativeContainer(var0);
   }

   public Window createInputMethodWindow(String var1, InputContext var2) {
      return new SimpleInputMethodWindow(var1, var2);
   }

   public boolean enableInputMethodsForTextComponent() {
      return false;
   }

   public static Locale getStartupLocale() {
      if (startupLocale == null) {
         String var0 = (String)AccessController.doPrivileged(new GetPropertyAction("user.language", "en"));
         String var1 = (String)AccessController.doPrivileged(new GetPropertyAction("user.region"));
         String var2;
         String var3;
         if (var1 != null) {
            int var4 = var1.indexOf(95);
            if (var4 >= 0) {
               var2 = var1.substring(0, var4);
               var3 = var1.substring(var4 + 1);
            } else {
               var2 = var1;
               var3 = "";
            }
         } else {
            var2 = (String)AccessController.doPrivileged(new GetPropertyAction("user.country", ""));
            var3 = (String)AccessController.doPrivileged(new GetPropertyAction("user.variant", ""));
         }

         startupLocale = new Locale(var0, var2, var3);
      }

      return startupLocale;
   }

   public Locale getDefaultKeyboardLocale() {
      return getStartupLocale();
   }

   protected static void setDataTransfererClassName(String var0) {
      dataTransfererClassName = var0;
   }

   public static String getDataTransfererClassName() {
      if (dataTransfererClassName == null) {
         Toolkit.getDefaultToolkit();
      }

      return dataTransfererClassName;
   }

   public WindowClosingListener getWindowClosingListener() {
      return this.windowClosingListener;
   }

   public void setWindowClosingListener(WindowClosingListener var1) {
      this.windowClosingListener = var1;
   }

   public RuntimeException windowClosingNotify(WindowEvent var1) {
      return this.windowClosingListener != null ? this.windowClosingListener.windowClosingNotify(var1) : null;
   }

   public RuntimeException windowClosingDelivered(WindowEvent var1) {
      return this.windowClosingListener != null ? this.windowClosingListener.windowClosingDelivered(var1) : null;
   }

   protected synchronized MouseInfoPeer getMouseInfoPeer() {
      if (mPeer == null) {
         mPeer = new DefaultMouseInfoPeer();
      }

      return mPeer;
   }

   public static boolean needsXEmbed() {
      String var0 = (String)AccessController.doPrivileged(new GetPropertyAction("sun.awt.noxembed", "false"));
      if ("true".equals(var0)) {
         return false;
      } else {
         Toolkit var1 = Toolkit.getDefaultToolkit();
         return var1 instanceof SunToolkit ? ((SunToolkit)var1).needsXEmbedImpl() : false;
      }
   }

   protected boolean needsXEmbedImpl() {
      return false;
   }

   protected final boolean isXEmbedServerRequested() {
      return (Boolean)AccessController.doPrivileged(new GetBooleanAction("sun.awt.xembedserver"));
   }

   public static boolean isModalExcludedSupported() {
      Toolkit var0 = Toolkit.getDefaultToolkit();
      return var0.isModalExclusionTypeSupported(DEFAULT_MODAL_EXCLUSION_TYPE);
   }

   protected boolean isModalExcludedSupportedImpl() {
      return false;
   }

   public static void setModalExcluded(Window var0) {
      var0.setModalExclusionType(DEFAULT_MODAL_EXCLUSION_TYPE);
   }

   public static boolean isModalExcluded(Window var0) {
      return var0.getModalExclusionType().compareTo(DEFAULT_MODAL_EXCLUSION_TYPE) >= 0;
   }

   public boolean isModalityTypeSupported(Dialog.ModalityType var1) {
      return var1 == ModalityType.MODELESS || var1 == ModalityType.APPLICATION_MODAL;
   }

   public boolean isModalExclusionTypeSupported(Dialog.ModalExclusionType var1) {
      return var1 == ModalExclusionType.NO_EXCLUDE;
   }

   public void addModalityListener(ModalityListener var1) {
      this.modalityListeners.add(var1);
   }

   public void removeModalityListener(ModalityListener var1) {
      this.modalityListeners.remove(var1);
   }

   public void notifyModalityPushed(Dialog var1) {
      this.notifyModalityChange(1300, var1);
   }

   public void notifyModalityPopped(Dialog var1) {
      this.notifyModalityChange(1301, var1);
   }

   final void notifyModalityChange(int var1, Dialog var2) {
      ModalityEvent var3 = new ModalityEvent(var2, this.modalityListeners, var1);
      var3.dispatch();
   }

   public static boolean isLightweightOrUnknown(Component var0) {
      if (!var0.isLightweight() && getDefaultToolkit() instanceof SunToolkit) {
         return !(var0 instanceof Button) && !(var0 instanceof Canvas) && !(var0 instanceof Checkbox) && !(var0 instanceof Choice) && !(var0 instanceof Label) && !(var0 instanceof List) && !(var0 instanceof Panel) && !(var0 instanceof Scrollbar) && !(var0 instanceof ScrollPane) && !(var0 instanceof TextArea) && !(var0 instanceof TextField) && !(var0 instanceof Window);
      } else {
         return true;
      }
   }

   static Method getMethod(Class var0, String var1, Class[] var2) {
      Method var3 = null;

      try {
         var3 = (Method)AccessController.doPrivileged(new 7(var0, var1, var2));
      } catch (PrivilegedActionException var5) {
         var5.printStackTrace();
      }

      return var3;
   }

   public void realSync() throws OperationTimedOut, InfiniteLoop {
      int var1 = 0;

      do {
         this.sync();

         int var2;
         for(var2 = 0; var2 < 0; ++var2) {
            this.syncNativeQueue();
         }

         while(this.syncNativeQueue() && var2 < 20) {
            ++var2;
         }

         if (var2 >= 20) {
            throw new InfiniteLoop();
         }

         for(var2 = 0; var2 < 0; ++var2) {
            this.waitForIdle();
         }

         while(this.waitForIdle() && var2 < 20) {
            ++var2;
         }

         if (var2 >= 20) {
            throw new InfiniteLoop();
         }

         ++var1;
      } while((this.syncNativeQueue() || this.waitForIdle()) && var1 < 20);

   }

   protected abstract boolean syncNativeQueue();

   private boolean isEQEmpty() {
      EventQueue var1 = this.getSystemEventQueueImpl();
      synchronized(SunToolkit.class) {
         if (eqNoEvents == null) {
            eqNoEvents = getMethod(EventQueue.class, "noEvents", (Class[])null);
         }
      }

      try {
         return (Boolean)eqNoEvents.invoke(var1);
      } catch (Exception var4) {
         var4.printStackTrace();
         return false;
      }
   }

   protected boolean waitForIdle() {
      flushPendingEvents();
      boolean var1 = this.isEQEmpty();
      this.queueEmpty = false;
      this.eventDispatched = false;
      synchronized(this.waitLock) {
         postEvent(AppContext.getAppContext(), new 8(this, this.getSystemEventQueueImpl(), (Runnable)null, 4L));

         try {
            while(!this.eventDispatched) {
               this.waitLock.wait();
            }
         } catch (InterruptedException var8) {
            return false;
         }
      }

      try {
         Thread.sleep(0L);
      } catch (InterruptedException var6) {
         throw new RuntimeException("Interrupted");
      }

      flushPendingEvents();
      synchronized(this.waitLock) {
         return !this.queueEmpty || !this.isEQEmpty() || !var1;
      }
   }

   public abstract void grab(Window var1);

   public abstract void ungrab(Window var1);

   public static native void closeSplashScreen();

   private void fireDesktopFontPropertyChanges() {
      this.setDesktopProperty("awt.font.desktophints", getDesktopFontHints());
   }

   public static void setAAFontSettingsCondition(boolean var0) {
      if (var0 != lastExtraCondition) {
         lastExtraCondition = var0;
         if (checkedSystemAAFontSettings) {
            checkedSystemAAFontSettings = false;
            Toolkit var1 = Toolkit.getDefaultToolkit();
            if (var1 instanceof SunToolkit) {
               ((SunToolkit)var1).fireDesktopFontPropertyChanges();
            }
         }
      }

   }

   private static RenderingHints getDesktopAAHintsByName(String var0) {
      Object var1 = null;
      var0 = var0.toLowerCase(Locale.ENGLISH);
      if (var0.equals("on")) {
         var1 = RenderingHints.VALUE_TEXT_ANTIALIAS_ON;
      } else if (var0.equals("gasp")) {
         var1 = RenderingHints.VALUE_TEXT_ANTIALIAS_GASP;
      } else if (!var0.equals("lcd") && !var0.equals("lcd_hrgb")) {
         if (var0.equals("lcd_hbgr")) {
            var1 = RenderingHints.VALUE_TEXT_ANTIALIAS_LCD_HBGR;
         } else if (var0.equals("lcd_vrgb")) {
            var1 = RenderingHints.VALUE_TEXT_ANTIALIAS_LCD_VRGB;
         } else if (var0.equals("lcd_vbgr")) {
            var1 = RenderingHints.VALUE_TEXT_ANTIALIAS_LCD_VBGR;
         }
      } else {
         var1 = RenderingHints.VALUE_TEXT_ANTIALIAS_LCD_HRGB;
      }

      if (var1 != null) {
         RenderingHints var2 = new RenderingHints((Map)null);
         var2.put(RenderingHints.KEY_TEXT_ANTIALIASING, var1);
         return var2;
      } else {
         return null;
      }
   }

   private static boolean useSystemAAFontSettings() {
      if (!checkedSystemAAFontSettings) {
         useSystemAAFontSettings = true;
         String var0 = null;
         Toolkit var1 = Toolkit.getDefaultToolkit();
         if (var1 instanceof SunToolkit) {
            var0 = (String)AccessController.doPrivileged(new GetPropertyAction("awt.useSystemAAFontSettings"));
         }

         if (var0 != null) {
            useSystemAAFontSettings = Boolean.valueOf(var0);
            if (!useSystemAAFontSettings) {
               desktopFontHints = getDesktopAAHintsByName(var0);
            }
         }

         if (useSystemAAFontSettings) {
            useSystemAAFontSettings = lastExtraCondition;
         }

         checkedSystemAAFontSettings = true;
      }

      return useSystemAAFontSettings;
   }

   protected RenderingHints getDesktopAAHints() {
      return null;
   }

   public static RenderingHints getDesktopFontHints() {
      if (useSystemAAFontSettings()) {
         Toolkit var0 = Toolkit.getDefaultToolkit();
         if (var0 instanceof SunToolkit) {
            RenderingHints var1 = ((SunToolkit)var0).getDesktopAAHints();
            return var1;
         } else {
            return null;
         }
      } else {
         return desktopFontHints != null ? (RenderingHints)((RenderingHints)desktopFontHints.clone()) : null;
      }
   }

   public abstract boolean isDesktopSupported();

   public static synchronized void consumeNextKeyTyped(KeyEvent var0) {
      if (consumeNextKeyTypedMethod == null) {
         consumeNextKeyTypedMethod = getMethod(DefaultKeyboardFocusManager.class, "consumeNextKeyTyped", new Class[]{KeyEvent.class});
      }

      try {
         consumeNextKeyTypedMethod.invoke(KeyboardFocusManager.getCurrentKeyboardFocusManager(), var0);
      } catch (IllegalAccessException var2) {
         var2.printStackTrace();
      } catch (InvocationTargetException var3) {
         var3.printStackTrace();
      }

   }

   // $FF: synthetic method
   static Field access$000() {
      return isPostedField;
   }

   // $FF: synthetic method
   static Object access$100(SunToolkit var0) {
      return var0.waitLock;
   }

   // $FF: synthetic method
   static boolean access$202(SunToolkit var0, boolean var1) {
      return var0.queueEmpty = var1;
   }

   // $FF: synthetic method
   static boolean access$300(SunToolkit var0) {
      return var0.isEQEmpty();
   }

   // $FF: synthetic method
   static boolean access$402(SunToolkit var0, boolean var1) {
      return var0.eventDispatched = var1;
   }

   static {
      AWT_LOCK_COND = AWT_LOCK.newCondition();
      peerMap = AWTAutoShutdown.getInstance().getPeerMap();
      appContextMap = Collections.synchronizedMap(new WeakHashMap());
      imgCache = new SoftCache();
      startupLocale = null;
      dataTransfererClassName = null;
      mPeer = null;
      DEFAULT_MODAL_EXCLUSION_TYPE = (Dialog.ModalExclusionType)AccessController.doPrivileged(new 6());
      lastExtraCondition = true;
      consumeNextKeyTypedMethod = null;
   }
}